package DataStorage;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;

import HibernateSQLite.java.model.Essieu;
import HibernateSQLite.java.util.HibernateUtil;

public class EssieuDAOHibernate extends
		GenericDAOHibernate<Essieu, Long, IEssieuDAO> implements IEssieuDAO {

	@SuppressWarnings("unchecked")
	public boolean isExist(String N_serie, String chemin, String flag_mesure,
			long InformationLigne_id) {
		try {
			List<Essieu> list = getSession()
					.createCriteria(Essieu.class)
					.add(Restrictions.eq("N_serie", N_serie))
					.add(Restrictions.eq("chemin", chemin))
					.add(Restrictions.eq("flag_mesure", flag_mesure))
					.add(Restrictions.eq("InformationLigne_id",
							InformationLigne_id)).list();
			if (!list.isEmpty()) {
				return true;
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}

		return false;
	}

	@SuppressWarnings("unchecked")
	public boolean isExist(Essieu essieu) {
		try {
			List<Essieu> list = getSession().createCriteria(Essieu.class)
					.list();
			if (list.contains(essieu)) {
				return true;
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}

		return false;
	}

	@SuppressWarnings("unchecked")
	public Essieu getEssieu(String N_serie, String flag_mesure) {
		try {
			List<Essieu> list = getSession().createCriteria(Essieu.class)
					.add(Restrictions.eq("N_serie", N_serie))
					.add(Restrictions.eq("flag_mesure", flag_mesure)).list();

			if (!list.isEmpty()) {
				for (Essieu essieu : list) {
					return essieu;
				}
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}

		return null;
	}

	@SuppressWarnings("unchecked")
	public Essieu getEssieu(String N_serie, String chemin, String flag_mesure,
			long InformationLigne_id) {
		try {
			List<Essieu> list = getSession()
					.createCriteria(Essieu.class)
					.add(Restrictions.eq("N_serie", N_serie))
					.add(Restrictions.eq("chemin", chemin))
					.add(Restrictions.eq("flag_mesure", flag_mesure))
					.add(Restrictions.eq("InformationLigne_id",
							InformationLigne_id)).list();

			if (!list.isEmpty()) {
				for (Essieu essieu : list) {
					return essieu;
				}
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}

		return null;
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieu() {
		try {
			List<Essieu> list = getSession().createCriteria(Essieu.class)
					.list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}

		return null;
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getEssieuByChemin(String chemin) {
		try {
			List<Essieu> list = getSession().createCriteria(Essieu.class)
					.add(Restrictions.eq("chemin", chemin)).list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieuByName_essieu(String name_essieu) {
		try {
			List<Essieu> list = getSession().createCriteria(Essieu.class)
					.add(Restrictions.eq("name_essieu", name_essieu)).list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}
		return null;

	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieuByDiversite(String diversite) {
		try {
			List<Essieu> list = getSession().createCriteria(Essieu.class)
					.add(Restrictions.eq("diversite", diversite)).list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieuByJour_production(String jour_production) {
		try {
			List<Essieu> list = getSession().createCriteria(Essieu.class)
					.add(Restrictions.eq("jour_production", jour_production))
					.list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieuByJour_mesure(String jour_mesure) {
		try {
			List<Essieu> list = getSession().createCriteria(Essieu.class)
					.add(Restrictions.eq("jour_mesure", jour_mesure)).list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieuByOperateur(String name_operateur) {
		try {
			List<Essieu> list = getSession()
					.createCriteria(Essieu.class)
					.add(Restrictions.like("name_operateur", "%"
							+ name_operateur + "%")).list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public String getMaxFlag_Mesure() {
		try {
			List<Essieu> listEssieu = getSession().createCriteria(Essieu.class)
					.list();
			List<Integer> listFlagMesure = new ArrayList<Integer>();
			for (Essieu essieu : listEssieu) {
				listFlagMesure.add(Integer.parseInt(essieu.getFlag_mesure()));
			}
			int max = 0;
			for (Integer flag : listFlagMesure) {
				if (flag != null && flag > max) {
					max = flag;
				}
			}
			return Integer.toString(max);
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}
		return null;
	}

	public void saveEssieu(String N_serie, String chemin, String Organe,
			String diversite, String annee, String jour_production,
			String jour_mesure, String name_operateur, String critere_name,
			int flag_mesure, String filePath, long InformationLigne_id) {

		Essieu essieu = null;

		Session session = null;
		Transaction ts = null;
		try {
			if(this.isExist(N_serie, chemin, Integer.toString(flag_mesure), InformationLigne_id)){
				Essieu oldEssieu = this.getEssieu(N_serie, chemin,
						Integer.toString(flag_mesure), InformationLigne_id);
				this.deleteEssieu(oldEssieu);
			}
			session = this.getSession();
			ts = session.beginTransaction();

			essieu = new Essieu();
			essieu.setN_serie(N_serie);
			essieu.setChemin(chemin);
			essieu.setOrgane(Organe);
			essieu.setDiversite(diversite);
			essieu.setAnnee(annee);
			essieu.setJour_production(jour_production);
			essieu.setJour_mesure(jour_mesure);
			essieu.setName_operateur(name_operateur);
			essieu.setCritere_name(critere_name);
			essieu.setFilePath(filePath);
			essieu.setFlag_mesure(Integer.toString(flag_mesure));
			essieu.setInformationLigne_id(InformationLigne_id);

			session.save(essieu);

			if (!ts.wasCommitted()) {
				ts.commit();
			}

		} catch (HibernateException e) {
			if (ts != null) {
				ts.rollback();
			}
			e.printStackTrace();
		} finally {
			this.closeSession();
		}

	}

	public void deleteEssieu(Essieu essieu) {
		try {
			// delete mesureTexts
			MesureTextDAOHibernate mesureTextDAO = new MesureTextDAOHibernate();
			String N_serie = essieu.getN_serie();
			String flag_mesure = essieu.getFlag_mesure();
			mesureTextDAO.deleteMesureTexts(N_serie, flag_mesure);

			this.getSession().delete(essieu);
			this.commit();
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieuByMeasure(String critere_name,
			String flag_mesure) {
		try {
			List<Essieu> list = this.getSession().createCriteria(Essieu.class)
					.add(Restrictions.eq("critere_name", critere_name))
					.add(Restrictions.eq("flag_mesure", flag_mesure)).list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}
		return null;
	}

	public void deleteListEssieuByMeasure(String critere_name,
			String flag_mesure) {
		try {
			List<Essieu> listEssieu = this.getListEssieuByMeasure(critere_name,
					flag_mesure);

			if (!listEssieu.isEmpty()) {
				for (Essieu essieu : listEssieu) {
					MesureTextDAOHibernate mesureTextDAO = new MesureTextDAOHibernate();
					mesureTextDAO.deleteMesureTexts(flag_mesure);
					this.delete(essieu);
				}
			} else {
				System.out.println("Does not exist these essieus !");
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSession();
		}

	}
	public void deleteAllEssieus(){
		//delete tous les essieus
		List<Essieu> list = this.getListEssieu();
		if(!list.isEmpty()){
			this.deleAll(list);
		}
		//delete tous les mesure texts
		MesureTextDAOHibernate mesureText = new MesureTextDAOHibernate();
		mesureText.deleteAllMesureTexts();
	}

	// --------------------------------------
	// for DB history
	// --------------------------------------

	@SuppressWarnings("unchecked")
	public String getMaxFlag_MesureInHistory() {
		try {

			List<Essieu> listEssieu = getSessionHistory().createCriteria(
					Essieu.class).list();

			List<Integer> listFlagMesure = new ArrayList<Integer>();
			for (Essieu essieu : listEssieu) {
				listFlagMesure.add(Integer.parseInt(essieu.getFlag_mesure()));
			}
			int max = 0;
			for (Integer flag : listFlagMesure) {
				if (flag != null && flag > max) {
					max = flag;
				}
			}
			return Integer.toString(max);
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSessionHistory();
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public boolean isExistInHistory(String N_serie, String chemin,
			String flag_mesure, long InformationLigne_id) {
		try {
			List<Essieu> list = getSessionHistory()
					.createCriteria(Essieu.class)
					.add(Restrictions.eq("N_serie", N_serie))
					.add(Restrictions.eq("chemin", chemin))
					.add(Restrictions.eq("flag_mesure", flag_mesure))
					.add(Restrictions.eq("InformationLigne_id",
							InformationLigne_id)).list();
			if (!list.isEmpty()) {
				return true;
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSessionHistory();
		}

		return false;
	}

	@SuppressWarnings("unchecked")
	public Essieu getEssieuFromHistory(String N_serie, String chemin,
			String flag_mesure, long InformationLigne_id) {
		try {
			List<Essieu> list = getSessionHistory()
					.createCriteria(Essieu.class)
					.add(Restrictions.eq("N_serie", N_serie))
					.add(Restrictions.eq("chemin", chemin))
					.add(Restrictions.eq("flag_mesure", flag_mesure))
					.add(Restrictions.eq("InformationLigne_id",
							InformationLigne_id)).list();

			if (!list.isEmpty()) {
				for (Essieu essieu : list) {
					return essieu;
				}
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSessionHistory();
		}
		return null;
	}

	public void saveEssieuToHistory(String N_serie, String chemin,
			String Organe, String diversite, String annee,
			String jour_production, String jour_mesure, String name_operateur,
			String critere_name, int flag_mesure, String filePath,
			long InformationLigne_id) {
		Essieu essieu = null;
		Session session = null;
		Transaction ts = null;
		try {
			if (this.isExistInHistory(N_serie, chemin, Integer.toString(flag_mesure),
					InformationLigne_id)) {
				Essieu oldEssieu = this.getEssieu(N_serie, chemin,
						Integer.toString(flag_mesure), InformationLigne_id);
				this.deleteFromHistory(oldEssieu);
			}
			session = this.getSessionHistory();
			ts = session.beginTransaction();
			essieu = new Essieu();
			essieu.setN_serie(N_serie);
			essieu.setChemin(chemin);
			essieu.setOrgane(Organe);
			essieu.setDiversite(diversite);
			essieu.setAnnee(annee);
			essieu.setJour_production(jour_production);
			essieu.setJour_mesure(jour_mesure);
			essieu.setName_operateur(name_operateur);
			essieu.setCritere_name(critere_name);
			essieu.setFilePath(filePath);
			essieu.setFlag_mesure(Integer.toString(flag_mesure));
			essieu.setInformationLigne_id(InformationLigne_id);

			session.save(essieu);

			if (!ts.wasCommitted()) {
				ts.commit();
			}
		} catch (HibernateException e) {
			if (ts != null) {
				ts.rollback();
			}
			e.printStackTrace();
		} finally {
			this.closeSessionHistory();
		}

	}

	public void deleteEssieuFromHistory(Essieu essieu) {
		try {
			getSessionHistory().delete(essieu);
			this.commitSessionHistory();
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSessionHistory();
		}
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieuFromHistory() {
		try {
			List<Essieu> list = this.getSessionHistory()
					.createCriteria(Essieu.class).list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSessionHistory();
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieuByMeasureFromHistory(String critere_name,
			String flag_mesure) {
		try {
			List<Essieu> list = this.getSessionHistory()
					.createCriteria(Essieu.class)
					.add(Restrictions.eq("critere_name", critere_name))
					.add(Restrictions.eq("flag_mesure", flag_mesure)).list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSessionHistory();
		}
		return null;
	}

	@SuppressWarnings("unchecked")
	public List<Essieu> getListEssieuHistory(String Organe, String diversite,
			String site, String N_ligne, String annee) {
		InformationLigneDAOHibernate informationLigneDAO = new InformationLigneDAOHibernate();
		long InformationLigne_id = informationLigneDAO.getInformationLigne_ID(
				Organe, diversite, site, N_ligne, annee);
		try {
			List<Essieu> list = this
					.getSessionHistory()
					.createCriteria(Essieu.class)
					.add(Restrictions.eq("InformationLigne_id",
							InformationLigne_id)).list();
			return list;
		} catch (HibernateException e) {
			e.printStackTrace();
		} finally {
			this.closeSessionHistory();
		}
		return null;
	}

	public void deleteListEssieuByMeasureFromHistory(String critere_name,
			String flag_mesure) {

		List<Essieu> listEssieu = this.getListEssieuByMeasureFromHistory(
				critere_name, flag_mesure);
		if (!listEssieu.isEmpty()) {
			for (Essieu essieu : listEssieu) {
				this.deleteEssieuFromHistory(essieu);
			}
		} else {
			System.out.println("DB History Does not exist these essieus !");
		}
	}
	
	public void deleteAllEssieusFromHistory(){
		List<Essieu> list = this.getListEssieuFromHistory();
		if(!list.isEmpty()){
			this.deleAllFromHistory(list);
		}
	}

	public static void main(String[] args) {

		EssieuDAOHibernate e = new EssieuDAOHibernate();

		String N_serie = "fz";
		String chemin = "j^spjfq^p";
		String Organe = "qsf";
		String diversite = "sqf";
		String annee = "2012";
		String jour_production = "";
		String jour_mesure = "J10013";
		String name_operateur = "JJD";
		String critere_name = "X1101";
		int flag_mesure = 1;
		String filePath = "I:\\sfszf";
		long InformationLigne_id = 1000;
		/*
		e.saveEssieu(N_serie, chemin, Organe, diversite, annee,
				jour_production, jour_mesure, name_operateur, critere_name,
				flag_mesure, filePath, InformationLigne_id);

		e.saveEssieuToHistory(N_serie, chemin, Organe, diversite, annee,
				jour_production, jour_mesure, name_operateur, critere_name,
				flag_mesure, filePath, InformationLigne_id);

		boolean isexist = e.isExist(N_serie, chemin,
				Integer.toString(flag_mesure), InformationLigne_id);
		System.out.println("isexist:" + isexist);
		Essieu essieu = e.getEssieu(N_serie, chemin,
				Integer.toString(flag_mesure), InformationLigne_id);
		Essieu essieuHistory = e.getEssieu(N_serie, chemin,
				Integer.toString(flag_mesure), InformationLigne_id);
		System.out.println("essieu"+essieu.getJour_analyse());
		System.out.println("essieuHistory"+essieuHistory.getJour_analyse());
		List<Essieu> listEssieu = e.getListEssieuByMeasure(critere_name, Integer.toString(flag_mesure));
		System.out.println("listEssieu"+listEssieu);
		List<Essieu> listEssieuHistory = e.getListEssieuByMeasureFromHistory(critere_name,Integer.toString(flag_mesure));
		System.out.println("listEssieuHistory"+listEssieuHistory);
		e.deleAllFromHistory(listEssieuHistory);
		*/
		e.deleteAllEssieus();
		e.deleteAllEssieusFromHistory();
	}
}
